home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2002 November / SGI Freeware 2002 November - Disc 2.iso / dist / fw_glimpse.idb / usr / freeware / src / glimpse-3.0 / agrep / newmgrep.c.z / newmgrep.c
C/C++ Source or Header  |  1997-09-09  |  63KB  |  1,827 lines
  1. /* Copyright (c) 1994 Sun Wu, Udi Manber, Burra Gopal.  All Rights Reserved. */
  2.  
  3. /* multipattern matcher */
  4.  
  5. #include <stdio.h>
  6. #include <ctype.h>
  7. #include <sys/stat.h>
  8. #include "agrep.h"
  9. #include <sys/time.h>
  10.  
  11. #define ddebug
  12. #define uchar unsigned char
  13. #undef    MAXPAT
  14. #define MAXPAT  256
  15. #undef    MAXLINE
  16. #define MAXLINE 1024
  17. #undef    MAXSYM
  18. #define MAXSYM  256
  19. #define MAXMEMBER1 32768
  20. /* #define MAXMEMBER1 262144 */ /*2^18 */ 
  21. #define MAXPATFILE 600000
  22. #define BLOCKSIZE  16384
  23. #define MAXHASH    32768 
  24. /* #define MAXHASH    262144 */
  25. #define mask5        32767
  26. #define max_num    40000
  27. #if    ISO_CHAR_SET
  28. #define W_DELIM       256
  29. #else
  30. #define W_DELIM       128
  31. #endif
  32. #define L_DELIM    10 
  33. #define Hbits 5 /* how much to shift to perform the hash */
  34.  
  35. extern int LIMITOUTPUT, LIMITPERFILE;
  36. extern int BYTECOUNT, PRINTOFFSET, PRINTRECORD, CurrentByteOffset;
  37. extern int MULTI_OUTPUT;    /* used by glimpse only if OR, never for AND */
  38. extern int DELIMITER;
  39. extern CHAR D_pattern[MaxDelimit*2];
  40. extern int D_length;
  41. extern CHAR tc_D_pattern[MaxDelimit*2];
  42. extern int tc_D_length;
  43. extern COUNT, FNAME, SILENT, FILENAMEONLY, prev_num_of_matched, num_of_matched;
  44. extern INVERSE, OUTTAIL;
  45. extern WORDBOUND, WHOLELINE, NOUPPER;
  46. extern ParseTree *AParse;
  47. extern int AComplexPattern;
  48. extern unsigned char  CurrentFileName[], Progname[]; 
  49. extern total_line;
  50. extern agrep_initialfd;
  51. extern int EXITONERROR;
  52. extern int PRINTPATTERN;
  53. extern int agrep_inlen;
  54. extern CHAR *agrep_inbuffer;
  55. extern FILE *agrep_finalfp;
  56. extern int agrep_outpointer;
  57. extern int agrep_outlen;
  58. extern CHAR * agrep_outbuffer;
  59. extern int errno;
  60. extern int NEW_FILE, POST_FILTER;
  61.  
  62. extern int tuncompressible();
  63. extern int quick_tcompress();
  64. extern int quick_tuncompress();
  65. extern int TCOMPRESSED;
  66. extern int EASYSEARCH;
  67. extern char FREQ_FILE[MAX_LINE_LEN], HASH_FILE[MAX_LINE_LEN], STRING_FILE[MAX_LINE_LEN];
  68. extern char PAT_FILE_NAME[MAX_LINE_LEN];
  69.  
  70. uchar SHIFT1[MAXMEMBER1];
  71.  
  72. int   LONG  = 0;
  73. int   SHORT = 0;
  74. int   p_size= 0;
  75.  
  76. uchar tr[MAXSYM];
  77. uchar tr1[MAXSYM];
  78. int   HASH[MAXHASH];
  79. int   Hash2[max_num];
  80. uchar *PatPtr[max_num];
  81. uchar *pat_spool = NULL; /* [MAXPATFILE+2*max_num+MAXPAT]; */
  82. uchar *patt[max_num];
  83. int   pat_len[max_num];
  84. int   pat_indices[max_num]; /* pat_indices[p] gives the actual index in matched_teriminals: used only with AParse != 0 */
  85. int num_pat;
  86.  
  87. extern char  amatched_terminals[MAXNUM_PAT]; /* which patterns have been matched in the current line? Used only with AParse != 0, so max_num is not needed */
  88. extern int anum_terminals;
  89. extern int AComplexBoolean;
  90. static void countline();
  91.  
  92. #if    DOTCOMPRESSED
  93. /* Equivalent variables for compression search */
  94. uchar tc_SHIFT1[MAXMEMBER1];
  95.  
  96. int   tc_LONG  = 0;
  97. int   tc_SHORT = 0;
  98. int   tc_p_size= 0;
  99.  
  100. uchar tc_tr[MAXSYM];
  101. uchar tc_tr1[MAXSYM];
  102. int   tc_HASH[MAXHASH];
  103. int   tc_Hash2[max_num];
  104. uchar *tc_PatPtr[max_num];
  105. uchar *tc_pat_spool = NULL; /* [MAXPATFILE+2*max_num+MAXPAT]; */
  106. uchar *tc_patt[max_num];
  107. int   tc_pat_len[max_num];
  108. int   tc_pat_indices[max_num]; /* pat_indices[p] gives the actual index in matched_teriminals: used only with AParse != 0 */
  109. int tc_num_pat;    /* must be the same as num_pat */
  110. #endif    /*DOTCOMPRESSED*/
  111.  
  112. static void f_prep();
  113. static void f_prep1();
  114. static void accumulate();
  115. #if    DOTCOMPRESSED
  116. static void tc_f_prep();
  117. static void tc_f_prep1();
  118. static void tc_accumulate();
  119. #endif
  120.  
  121. #ifdef perf_check
  122.     int cshift=0, cshift0=0, chash=0;
  123. #endif
  124.  
  125. /*
  126.  * General idea behind output processing with delimiters, inverse, compression, etc.
  127.  * CAUTION: In compressed files, we can search ONLY for simple patterns or their ;,.
  128.  * Attempts to search for complex patterns / with errors might lead to spurious matches.
  129.  * 1. Once we find the match, go back and forward to get the delimiters that surround
  130.  *    the matched region.
  131.  * 2. If it is a compressed file, verify that the match is "real" (compressed files
  132.  *    can have pseudo matches hence this filtering step is required).
  133.  * 3. Increment num_of_matched.
  134.  * 4. Process some output options which print stuff before the matched region is
  135.  *    printed.
  136.  * 5. If there is compression, decomress and output the matched region. Otherwise
  137.  *    just output it as is. Remember, from step (1) we know the matched region.
  138.  * 6. If inverse is set, then we must keep track of the end of the last matched region
  139.  *    in the variable lastout. When there is a match, we must print everything from
  140.  *    lastout to the beginning of the current matched region (curtextbegin) and then
  141.  *    update lastout to point to the end of the current matched region (curtextend).
  142.  *    ALSO: if we exit from the main loops, we must output everything from the end
  143.  *    of the last matched region to the end of the input buffer.
  144.  * 7. Delimiter handling in complex patterns is different: there the search is done
  145.  *    for a boolean and of the delimiter pattern and the actual pattern.
  146.  * 8. For convenience and speed, the multipattern matching routines to handle
  147.  *    compressed files have been separated from their (normal) counterparts.
  148.  * 9. One special note on handling complicated boolean patterns: the parse
  149.  *    tree will be the same for both compressed and uncomrpessed patterns and the
  150.  *    same amatched_terminals array will be used in both. BUT, the pat_spool and
  151.  *    pat_index, etc., will be different as they refer to the individual terminals.
  152.  */
  153.  
  154. int
  155. prepf(mfp, mbuf, mlen)
  156. int mfp, mlen;
  157. unsigned char *mbuf;
  158. {
  159.     int length=0, i, p=1;
  160.     uchar *pat_ptr;
  161.     unsigned Mask = 31;
  162.     int num_read;
  163.     unsigned char *buf;
  164.     struct stat stbuf;
  165.     int j, k;    /* to implement \\ */
  166.  
  167.         if ((mfp == -1) && ((mbuf == NULL) || (mlen <= 0))) return -1;
  168.  
  169.     if (mfp != -1) {
  170.         if (fstat(mfp, &stbuf) == -1) {
  171.             fprintf(stderr, "%s: cannot stat file: %s\n", Progname, PAT_FILE_NAME);
  172.             return -1;
  173.         }
  174.         if (!S_ISREG(stbuf.st_mode)) {
  175.             fprintf(stderr, "%s: pattern file not regular file: %s\n", Progname, PAT_FILE_NAME);
  176.             return -1;
  177.         }
  178.         if (stbuf.st_size*2 > MAXPATFILE + 2*max_num) {
  179.             fprintf(stderr, "%s: pattern file too large (> %d B): %s\n", Progname, (MAXPATFILE+2*max_num)/2, PAT_FILE_NAME);
  180.             return -1;
  181.         }
  182.         if (pat_spool != NULL) free(pat_spool);
  183.         pat_ptr = pat_spool = (unsigned char *)malloc(stbuf.st_size*2 + MAXPAT);
  184.         alloc_buf(mfp, &buf, MAXPATFILE+2*BLOCKSIZE);
  185.         while((num_read = fill_buf(mfp, buf+length, 2*BLOCKSIZE)) > 0) {
  186.             length = length + num_read;
  187.             if(length > MAXPATFILE) {
  188.                 fprintf(stderr, "%s: maximum pattern file size is %d\n", Progname, MAXPATFILE);
  189.                                 if (!EXITONERROR) {
  190.                                         errno = AGREP_ERROR;
  191.                                         free_buf(mfp, buf);
  192.                                         return -1;
  193.                                 }
  194.                                 else exit(2);
  195.             }
  196.         }
  197.     }
  198.     else {
  199.         buf = mbuf;
  200.         length = mlen;
  201.         if (mlen*2 > MAXPATFILE + 2*max_num) {
  202.             fprintf(stderr, "%s: pattern buffer too large (> %d B)\n", Progname, (MAXPATFILE+2*max_num)/2);
  203.             return -1;
  204.         }
  205.         if (pat_spool != NULL) free(pat_spool);
  206.         pat_ptr = pat_spool = (unsigned char *)malloc(mlen*2 + MAXPAT);
  207.     }
  208.  
  209.     /* Now all the patterns are in buf */
  210.     buf[length] = '\n';
  211.     i=0; p=1;
  212. /* removed by Udi 11/8/94 - we now do WORDBOUND "by hand" 
  213.     if(WORDBOUND) {
  214.         while(i<length) {
  215.             patt[p] = pat_ptr;
  216.             *pat_ptr++ = W_DELIM;
  217.             while((i<length) && ((*pat_ptr = buf[i++]) != '\n')) pat_ptr++;
  218.             *pat_ptr++ = W_DELIM;
  219.             *pat_ptr++ = 0;
  220.             p++;
  221.         }
  222.     }
  223.     else
  224. */
  225.     if(WHOLELINE) {
  226.         while(i<length) {
  227.             patt[p] = pat_ptr;
  228.             *pat_ptr++ = L_DELIM;
  229.             while((i<length) && ((*pat_ptr = buf[i++]) != '\n')) pat_ptr++;
  230.             *pat_ptr++ = L_DELIM;
  231.             *pat_ptr++ = 0;
  232.             p++;
  233.         }
  234.     }
  235.     else {
  236.         while(i < length) {
  237.             patt[p] = pat_ptr;
  238.             while((i<length) && ((*pat_ptr = buf[i++]) != '\n')) pat_ptr++;
  239.             *pat_ptr++ = 0;
  240.             p++;  
  241.         }
  242.     }
  243.  
  244.     /* Now, the patterns have been copied into patt[] */
  245.     if(p>max_num) {
  246.         fprintf(stderr, "%s: maximum number of patterns is %d\n", Progname, max_num); 
  247.                 if (!EXITONERROR) {
  248.                         errno = AGREP_ERROR;
  249.                         free_buf(mfp, buf);
  250.                         return -1;
  251.                 }
  252.                 else exit(2);
  253.  
  254.     }
  255.  
  256.     for(i=1; i<20; i++) *pat_ptr = i;  /* boundary safety zone */
  257.  
  258.     /* I might have to keep changing tr s.t. mgrep won't get confused with W_DELIM */
  259.     for(i=0; i< MAXSYM; i++) tr[i] = i;
  260.     if(NOUPPER) {
  261.                 for (i=0; i<MAXSYM; i++)
  262.                         if (isupper(i)) tr[i] = tr[tolower(i)];
  263.         /* for(i='A'; i<= 'Z'; i++) tr[i] = i + 'a' - 'A'; */
  264.     }
  265. /*
  266.     if(WORDBOUND) {
  267.         for(i=1; i<MAXSYM; i++) if(!isalnum(i)) tr[i] = W_DELIM;
  268.     }
  269. removed by Udi 11/8/94 - the trick of using W-delim was too buggy.
  270. we now do it "by hand" after we find a match 
  271. */
  272.     for(i=0; i< MAXSYM; i++) tr1[i] = tr[i]&Mask;
  273.     num_pat =  p-1;
  274.     p_size  =  MAXPAT;
  275.     for(i=1; i<=num_pat; i++) {
  276.         p = strlen(patt[i]);
  277.         if ((patt[i][0] == '^') || (patt[i][0] == '$')) patt[i][0] = '\n';
  278.         if ((p > 1) && ((patt[i][p-1] == '^') || (patt[i][p-1] == '$')) && (patt[i][p-2] != '\\')) patt[i][p-1] = '\n';
  279.  
  280.         /* Added by bg, Dec 2nd 1994 */
  281.         for (k=0; k<p; k++) {
  282.             if (patt[i][k] == '\\') {
  283.                 for (j=k; j<p; j++)
  284.                     patt[i][j] = patt[i][j+1]; /* including '\0' */
  285.                 p--;
  286.             }
  287.         }
  288.  
  289.         pat_len[i] = p;
  290.         /*
  291.         pat_len[i] = (WORDBOUND?(p-2>0?p-2:1):p);  changed by Udi 11/8/94
  292.         */
  293. #ifdef    debug
  294.         printf("prepf(): patt[%d]=%s, pat_len[%d]=%d\n", i, patt[i], i, pat_len[i]);
  295. #endif
  296.         if(p!=0 && p < p_size) p_size = p;    /* MIN */
  297.     }
  298.     if(p_size == 0) {
  299.         fprintf(stderr, "%s: the pattern file is empty\n", Progname);
  300.                 if (!EXITONERROR) {
  301.                         errno = AGREP_ERROR;
  302.                         free_buf(mfp, buf);
  303.                         return -1;
  304.                 }
  305.                 else exit(2);
  306.     }
  307.     if(length > 400 && p_size > 2) LONG = 1;
  308.     if(p_size == 1) SHORT = 1;
  309.     for(i=0; i<MAXMEMBER1; i++) SHIFT1[i] = p_size - 1 - LONG;
  310.     for(i=0; i<MAXHASH; i++) {
  311.         HASH[i] = 0;
  312.     }
  313.     for(i=1; i<=num_pat; i++) f_prep(i, patt[i]);
  314.     accumulate();
  315.     memset(pat_indices, '\0', sizeof(int) * (num_pat + 1));
  316.     for(i=1; i<=num_pat; i++) f_prep1(i, patt[i]);
  317.  
  318. #if    DOTCOMPRESSED
  319.     /* prepf for compression */
  320.     if (-1 == tc_prepf(buf, length)) {
  321.         free_buf(mfp, buf);
  322.         return -1;
  323.     }
  324. #endif    /*DOTCOMPRESSED*/
  325.         free_buf(mfp, buf);
  326.         return 0;
  327. }
  328.  
  329. #if    DOTCOMPRESSED
  330. /*
  331.  * Compression equivalent of prepf: called right after prepf.
  332.  * 1. Read patt and SHIFT1
  333.  * 2. Call tcompress on the patterns in patt and put in tc_patt.
  334.  * 3. Use these patterns to compute tc_SHIFT (ignore WDELIM, LDELIM, case sensitivity, etc.)
  335.  * 4. Process other variables/functions (pat_spool, tr, tr1, pat_len, accumulate, SHIFT1, f_prep, f_prep1, pat_indices) appropriately.
  336.  */
  337. int
  338. tc_prepf(buf, length)
  339. unsigned char *buf;
  340. int    length;
  341. {
  342.     int i, p=1;
  343.     uchar *pat_ptr;
  344.     unsigned Mask = 31;
  345.     int tc_length;
  346.     unsigned char tc_buf[MAXPAT * 2];    /* maximum length of the compressed pattern */
  347.     static struct timeval initt, finalt;
  348.  
  349.     if (length*2 > MAXPATFILE + 2*max_num) {
  350.         fprintf(stderr, "%s: pattern buffer too large (> %d B)\n", Progname, (MAXPATFILE+2*max_num)/2);
  351.         return -1;
  352.     }
  353.     if (tc_pat_spool != NULL) free(tc_pat_spool);
  354.     pat_ptr = tc_pat_spool = (unsigned char *)malloc(length*2 + MAXPAT);
  355.  
  356. #if    MEASURE_TIMES
  357.     gettimeofday(&initt, NULL);
  358. #endif    /*MEASURE_TIMES*/
  359.  
  360.     i=0; p=1;
  361.     while(i < length) {
  362.         tc_patt[p] = pat_ptr;
  363.         while((*pat_ptr = buf[i++]) != '\n') pat_ptr++;
  364.         *pat_ptr++ = 0;
  365.         if ((tc_length = quick_tcompress(FREQ_FILE, HASH_FILE, tc_patt[p], strlen(tc_patt[p]), tc_buf, MAXPAT * 2 - 8, TC_EASYSEARCH)) > 0) {
  366.             memcpy(tc_patt[p], tc_buf, tc_length);
  367.             tc_patt[p][tc_length] = '\0';
  368.             pat_ptr = tc_patt[p] + tc_length + 1;    /* character after '\0' */
  369.         }
  370.         p++;  
  371.     }
  372.  
  373.     for(i=1; i<20; i++) *pat_ptr = i;  /* boundary safety zone */
  374.  
  375.     /* Ignore all other options: it is automatically W_DELIM */
  376.     for(i=0; i< MAXSYM; i++) tc_tr[i] = i;
  377.     for(i=0; i< MAXSYM; i++) tc_tr1[i] = tc_tr[i]&Mask;
  378.     tc_num_pat =  p-1;
  379.     tc_p_size  =  MAXPAT;
  380.     for(i=1; i<=num_pat; i++) {
  381.         p = strlen(tc_patt[i]);
  382.         tc_pat_len[i] = p;
  383. #ifdef    debug
  384.         printf("prepf(): tc_patt[%d]=%s, tc_pat_len[%d]=%d\n", i, tc_patt[i], i, tc_pat_len[i]);
  385. #endif
  386.         if(p!=0 && p < tc_p_size) tc_p_size = p;    /* MIN */
  387.     }
  388.     if(tc_p_size == 0) {    /* cannot happen NOW */
  389.         fprintf(stderr, "%s: the pattern file is empty\n", Progname);
  390.                 if (!EXITONERROR) {
  391.                         errno = AGREP_ERROR;
  392.                         return -1;
  393.                 }
  394.                 else exit(2);
  395.     }
  396.     if(length > 400 && tc_p_size > 2) tc_LONG = 1;
  397.     if(tc_p_size == 1) tc_SHORT = 1;
  398.     for(i=0; i<MAXMEMBER1; i++) tc_SHIFT1[i] = tc_p_size - 1 - LONG;
  399.     for(i=0; i<MAXHASH; i++) {
  400.         tc_HASH[i] = 0;
  401.     }
  402.     for(i=1; i<=tc_num_pat; i++) tc_f_prep(i, tc_patt[i]);
  403.     tc_accumulate();
  404.     memset(tc_pat_indices, '\0', sizeof(int) * (tc_num_pat + 1));
  405.     for(i=1; i<=tc_num_pat; i++) tc_f_prep1(i, tc_patt[i]);
  406.  
  407. #if    MEASURE_TIMES
  408.     gettimeofday(&finalt, NULL);
  409.     INFILTER_ms +=  (finalt.tv_sec*1000 + finalt.tv_usec/1000) - (initt.tv_sec*1000 + initt.tv_usec/1000);
  410. #endif    /*MEASURE_TIMES*/
  411.         return 0;
  412. }
  413. #endif    /*DOTCOMPRESSED*/
  414.  
  415. int
  416. mgrep(fd)
  417. int fd;
  418. { 
  419.     register char r_newline = '\n';
  420.     unsigned char *text;
  421.     register int buf_end, num_read, start, end, residue = 0;
  422.     int    oldCurrentByteOffset;
  423.     int    first_time = 1;
  424.  
  425. #if     AGREP_POINTER
  426.         if (fd != -1) {
  427. #endif  /*AGREP_POINTER*/
  428.                 alloc_buf(fd, &text, 2*BLOCKSIZE+MAXLINE);
  429.         text[MAXLINE-1] = '\n';  /* initial case */
  430.         start = MAXLINE;
  431.  
  432.         while( (num_read = fill_buf(fd, text+MAXLINE, 2*BLOCKSIZE)) > 0) 
  433.         {
  434.             buf_end = end = MAXLINE + num_read -1 ;
  435.             oldCurrentByteOffset = CurrentByteOffset;
  436.  
  437.             if (first_time) {
  438.                 if ((TCOMPRESSED == ON) && tuncompressible(text+MAXLINE, num_read)) {
  439.                     EASYSEARCH = text[MAXLINE+SIGNATURE_LEN-1];
  440.                     start += SIGNATURE_LEN;
  441.                     CurrentByteOffset += SIGNATURE_LEN;
  442.                     if (!EASYSEARCH) {
  443.                         fprintf(stderr, "not compressed for easy-search: can miss some matches in: %s\n", CurrentFileName);
  444.                     }
  445.                 }
  446.                 else TCOMPRESSED = OFF;
  447.                 first_time = 0;
  448.             }
  449.  
  450.             if (!DELIMITER) {
  451.                 while(text[end]  != r_newline && end > MAXLINE) end--;
  452.                 text[start-1] = r_newline;
  453.             }
  454.             else {
  455.                 unsigned char *newbuf = text + end + 1;
  456.                 newbuf = backward_delimiter(newbuf, text+MAXLINE, D_pattern, D_length, OUTTAIL);    /* see agrep.c/'d' */
  457.                 if (newbuf < text+MAXLINE+D_length) newbuf = text + end + 1;
  458.                 end = newbuf - text - 1;
  459.                 memcpy(text+start-D_length, D_pattern, D_length);
  460.             }
  461.             residue = buf_end - end  + 1 ;
  462.             if(INVERSE && COUNT) countline(text+MAXLINE, num_read);
  463.  
  464.             /* MGREP_PROCESS */
  465.             if (TCOMPRESSED) {    /* separate functions since separate globals => too many if-statements within a single function makes it slow */
  466. #if    DOTCOMPRESSED
  467.                 if(tc_SHORT) { if (-1 == tc_m_short(text, start, end)) {free_buf(fd, text); return -1;}}
  468.                 else      { if (-1 == tc_monkey1(text, start, end)) {free_buf(fd, text); return -1;}}
  469. #endif    /*DOTCOMPRESSED*/
  470.             }
  471.             else {
  472.                 if(SHORT) { if (-1 == m_short(text, start, end)) {free_buf(fd, text); return -1;}}
  473.                 else      { if (-1 == monkey1(text, start, end)) {free_buf(fd, text); return -1;}}
  474.             }
  475.                         if(FILENAMEONLY && (num_of_matched - prev_num_of_matched) && (NEW_FILE || !POST_FILTER)) {
  476.                                 if (agrep_finalfp != NULL)
  477.                                         fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  478.                                 else {
  479.                                         int outindex;
  480.                                         for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  481.                                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  482.                                                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  483.                                         }
  484.                                         if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  485.                                                 OUTPUT_OVERFLOW;
  486.                                                 free_buf(fd, text);
  487.                                                 return -1;
  488.                                         }
  489.                                         else {
  490.                                                 agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  491.                                         }
  492.                                         agrep_outpointer += outindex;
  493.                                 }
  494.                                 free_buf(fd, text);
  495.                                 NEW_FILE = OFF;
  496.                                 return 0;
  497.                         }
  498.  
  499.             CurrentByteOffset = oldCurrentByteOffset + end - start + 1;
  500.             start = MAXLINE - residue;
  501.             if(start < 0) {
  502.                 start = 1; 
  503.             }
  504.             strncpy(text+start, text+end, residue);
  505.  
  506.             if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
  507.                 ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
  508.                 free_buf(fd, text);
  509.                 return 0;    /* done */
  510.             }
  511.         } /* end of while(num_read = ... */
  512.         if (!DELIMITER) {
  513.             text[start-1] = '\n';
  514.             text[start+residue] = '\n';
  515.         }
  516.         else {
  517.             if (start > D_length) memcpy(text+start-D_length, D_pattern, D_length);
  518.             memcpy(text+start+residue, D_pattern, D_length);
  519.         }
  520.         end = start + residue;
  521.         if(residue > 1) {
  522.             if (TCOMPRESSED) {
  523. #if    DOTCOMPRESSED
  524.                 if(tc_SHORT) tc_m_short(text, start, end);
  525.                 else      tc_monkey1(text, start, end);
  526. #endif    /*DOTCOMPRESSED*/
  527.             }
  528.             else {
  529.                 if(SHORT) m_short(text, start, end);
  530.                 else      monkey1(text, start, end);
  531.             }
  532.                         if(FILENAMEONLY && (num_of_matched - prev_num_of_matched) && (NEW_FILE || !POST_FILTER)) {
  533.                                 if (agrep_finalfp != NULL)
  534.                                         fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  535.                                 else {
  536.                                         int outindex;
  537.                                         for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  538.                                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  539.                                                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  540.                                         }
  541.                                         if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  542.                                                 OUTPUT_OVERFLOW;
  543.                                                 free_buf(fd, text);
  544.                                                 return -1;
  545.                                         }
  546.                                         else {
  547.                                                 agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  548.                                         }
  549.                                         agrep_outpointer += outindex;
  550.                                 }
  551.                                 free_buf(fd, text);
  552.                                 NEW_FILE = OFF;
  553.                                 return 0;
  554.                         }
  555.         }
  556.         free_buf(fd, text);
  557.         return (0);
  558. #if    AGREP_POINTER
  559.     }
  560.     else {
  561.                 text = (unsigned char *)agrep_inbuffer;
  562.                 num_read = agrep_inlen;
  563.                 start = 0;
  564.                 buf_end = end = num_read - 1;
  565.  
  566.             oldCurrentByteOffset = CurrentByteOffset;
  567.  
  568.             if (first_time) {
  569.                 if ((TCOMPRESSED == ON) && tuncompressible(text+MAXLINE, num_read)) {
  570.                     EASYSEARCH = text[MAXLINE+SIGNATURE_LEN-1];
  571.                     start += SIGNATURE_LEN;
  572.                     CurrentByteOffset += SIGNATURE_LEN;
  573.                     if (!EASYSEARCH) {
  574.                         fprintf(stderr, "not compressed for easy-search: can miss some matches in: %s\n", CurrentFileName);
  575.                     }
  576.                 }
  577.                 else TCOMPRESSED = OFF;
  578.                 first_time = 0;
  579.             }
  580.  
  581.             if (!DELIMITER)
  582.                 while(text[end]  != r_newline && end > 1) end--;
  583.             else {
  584.                                 unsigned char *newbuf = text + end + 1;
  585.                                 newbuf = backward_delimiter(newbuf, text, D_pattern, D_length, OUTTAIL);        /* see agrep.c/'d' */
  586.                 if (newbuf < text+D_length) newbuf = text + end + 1;
  587.                                 end = newbuf - text - 1;
  588.             }
  589.             /* text[0] = text[end] = r_newline; : the user must ensure that the delimiter is there at text[0] and occurs somewhere before text[end] */
  590.  
  591.             if (INVERSE && COUNT) countline(text, num_read);
  592.  
  593.                         /* An exact copy of the above MGREP_PROCESS */
  594.             if (TCOMPRESSED) {    /* separate functions since separate globals => too many if-statements within a single function makes it slow */
  595. #if    DOTCOMPRESSED
  596.                 if(tc_SHORT) { if (-1 == tc_m_short(text, start, end)) {free_buf(fd, text); return -1;}}
  597.                 else      { if (-1 == tc_monkey1(text, start, end)) {free_buf(fd, text); return -1;}}
  598. #endif    /*DOTCOMPRESSED*/
  599.             }
  600.             else {
  601.                 if(SHORT) { if (-1 == m_short(text, start, end)) {free_buf(fd, text); return -1;}}
  602.                 else      { if (-1 == monkey1(text, start, end)) {free_buf(fd, text); return -1;}}
  603.             }
  604.                         if(FILENAMEONLY && (num_of_matched - prev_num_of_matched) && (NEW_FILE || !POST_FILTER)) {
  605.                                 if (agrep_finalfp != NULL)
  606.                                         fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  607.                                 else {
  608.                                         int outindex;
  609.                                         for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  610.                                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  611.                                                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  612.                                         }
  613.                                         if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  614.                                                 OUTPUT_OVERFLOW;
  615.                                                 free_buf(fd, text);
  616.                                                 return -1;
  617.                                         }
  618.                                         else {
  619.                                                 agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  620.                                         }
  621.                                         agrep_outpointer += outindex;
  622.                                 }
  623.                                 free_buf(fd, text);
  624.                                 NEW_FILE = OFF;
  625.                                 return 0;
  626.                         }
  627.  
  628.                 return 0;
  629.     }
  630. #endif    /*AGREP_POINTER*/
  631. #ifdef perf_check
  632.     fprintf(stderr,"Shifted %d times; shift=0 %d times; hash was = %d times\n",cshift, cshift0, chash);
  633.     return 0;
  634. #endif
  635. } /* end mgrep */
  636.  
  637. static void
  638. countline(text, len)
  639. unsigned char *text; int len;
  640. {
  641. int i;
  642.     for (i=0; i<len; i++) if(text[i] == '\n') total_line++;
  643. }
  644.  
  645. /* Stuff that always needs to be printed whenever there is a match in all functions in this file */
  646. int
  647. print_options(pat_index, text, curtextbegin, curtextend)
  648.     int    pat_index;
  649.     unsigned char    *text, *curtextbegin, *curtextend;
  650. {
  651.     int    PRINTED = 0;
  652.     if(FNAME && (NEW_FILE || !POST_FILTER)) {
  653.         char    nextchar = (POST_FILTER == ON)?'\n':' ';
  654.         char    *prevstring = (POST_FILTER == ON)?"\n":"";
  655.         if (agrep_finalfp != NULL)
  656.             fprintf(agrep_finalfp, "%s%s:%c", prevstring, CurrentFileName, nextchar);
  657.         else {
  658.             int outindex;
  659.             if (prevstring[0] != '\0') {
  660.                 if(agrep_outpointer + 1 >= agrep_outlen) {
  661.                     OUTPUT_OVERFLOW;
  662.                     return -1;
  663.                 }
  664.                 else agrep_outbuffer[agrep_outpointer ++] = prevstring[0];
  665.             }
  666.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  667.                     (CurrentFileName[outindex] != '\0'); outindex++) {
  668.                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  669.             }
  670.             if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+2>=agrep_outlen)) {
  671.                 OUTPUT_OVERFLOW;
  672.                 return -1;
  673.             }
  674.             else {
  675.                 agrep_outbuffer[agrep_outpointer+outindex++] = ':';
  676.                 agrep_outbuffer[agrep_outpointer+outindex++] = nextchar;
  677.             }
  678.             agrep_outpointer += outindex;
  679.         }
  680.         NEW_FILE = OFF;
  681.         PRINTED = 1;
  682.     }
  683.  
  684.     if (PRINTPATTERN) {
  685.         if (agrep_finalfp != NULL)
  686.             fprintf(agrep_finalfp, "%d- ", pat_index);
  687.         else {
  688.             char s[32];
  689.             int outindex;
  690.             sprintf(s, "%d- ", pat_index);
  691.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  692.                     (s[outindex] != '\0'); outindex++) {
  693.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  694.             }
  695.             if (s[outindex] != '\0') {
  696.                 OUTPUT_OVERFLOW;
  697.                 return -1;
  698.             }
  699.             agrep_outpointer += outindex;
  700.         }
  701.         PRINTED = 1;
  702.     }
  703.  
  704.     if (BYTECOUNT) {
  705.         if (agrep_finalfp != NULL)
  706.             fprintf(agrep_finalfp, "%d= ", CurrentByteOffset);
  707.         else {
  708.             char s[32];
  709.             int outindex;
  710.             sprintf(s, "%d= ", CurrentByteOffset);
  711.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  712.                     (s[outindex] != '\0'); outindex++) {
  713.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  714.             }
  715.             if (s[outindex] != '\0') {
  716.                 OUTPUT_OVERFLOW;
  717.                 return -1;
  718.             }
  719.             agrep_outpointer += outindex;
  720.         }
  721.         PRINTED = 1;
  722.     }
  723.  
  724.     if (PRINTOFFSET) {
  725.         if (agrep_finalfp != NULL)
  726.             fprintf(agrep_finalfp, "@%d{%d} ", CurrentByteOffset - (text -curtextbegin), curtextend-curtextbegin);
  727.         else {
  728.             char s[32];
  729.             int outindex;
  730.             sprintf(s, "@%d{%d} ", CurrentByteOffset - (text -curtextbegin), curtextend-curtextbegin);
  731.             for (outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  732.                      (s[outindex] != '\0'); outindex ++) {
  733.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  734.             }
  735.             if (s[outindex] != '\0') {
  736.                 OUTPUT_OVERFLOW;
  737.                 return -1;
  738.             }
  739.             agrep_outpointer += outindex;
  740.         }
  741.         PRINTED = 1;
  742.     }
  743.     return PRINTED;
  744. }
  745.  
  746. int
  747. monkey1( text, start, end  ) 
  748. int start, end; register unsigned char *text;
  749. {
  750.     int PRINTED = 0;
  751.         unsigned char *oldtext;
  752.     int pat_index;
  753.     register uchar *textend;
  754.     unsigned char *textbegin;
  755.     unsigned char *curtextend;
  756.     unsigned char *curtextbegin;
  757.     register unsigned hash;
  758.     register uchar shift;
  759.     register int  m1, Long=LONG;
  760.     int MATCHED=0;
  761.     register uchar *qx;
  762.     register uchar *px;
  763.     register int p, p_end;
  764.     uchar *lastout;
  765.     /* int OUT=0; */
  766.     int hash2;
  767.     int j;
  768.     int DOWITHMASK;
  769.  
  770.     DOWITHMASK = 0;
  771.     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  772.     textbegin = text + start;
  773.     textend = text + end;
  774.     m1 = p_size-1;
  775.     lastout = text+start;
  776.     text = text + start + m1 -1 ;
  777.     /* -1 to allow match to the first \n in case the pattern has ^ in front of it */
  778. /*
  779.     if (WORDBOUND || WHOLELINE) text = text-1;
  780.     if (WHOLELINE) text = text-1;
  781. */
  782.         /* to accomodate the extra 2 W_delim */
  783.     while (text <= textend) {
  784.         hash=tr1[*text];
  785.         hash=(hash<<Hbits)+(tr1[*(text-1)]);
  786.         if(Long) hash=(hash<<Hbits)+(tr1[*(text-2)]);
  787.         shift = SHIFT1[hash];
  788. #ifdef perf_check
  789.         cshift++;
  790. #endif
  791.         if(shift == 0) {
  792.             hash=hash&mask5;
  793.             hash2 = (tr[*(text-m1)]<<8) + tr[*(text-m1+1)];
  794.             p = HASH[hash];
  795. #ifdef perf_check
  796.             cshift0++;
  797. #endif
  798.             p_end = HASH[hash+1];
  799. #ifdef debug
  800.             printf("hash=%d, p=%d, p_end=%d\n", hash, p, p_end);
  801. #endif
  802.             while(p++ < p_end) {
  803.                 if(hash2 != Hash2[p]) continue;
  804. #ifdef perf_check
  805.                 chash++;
  806. #endif
  807.                 if (((pat_index = pat_indices[p]) <= 0) || (pat_len[pat_index] <= 0)) continue;
  808.                 px = PatPtr[p];
  809.                 qx = text-m1;
  810.                 while((*px!=0)&&(tr[*px] == tr[*qx])) {
  811.                     px++;
  812.                     qx++;
  813.                 }
  814.                 if (*px == 0) {
  815.                     if(text > textend) return 0;
  816.                     if (WORDBOUND) {
  817.                         if (isalnum(*qx)) goto skip_output;
  818.                         if (isalnum(*(text-m1-1))) goto skip_output;
  819.                     }
  820.                     if (!DOWITHMASK) {
  821.                                                 /* Don't update CurrentByteOffset here: only before outputting properly */
  822.                                                 if (!DELIMITER) {
  823.                             curtextbegin = text; while((curtextbegin > textbegin) && (*(--curtextbegin) != '\n'));
  824.                             if (*curtextbegin == '\n') curtextbegin ++;
  825.                             curtextend = text+1; while((curtextend < textend) && (*curtextend != '\n')) curtextend ++;
  826.                             if (*curtextend == '\n') curtextend ++;
  827.                                                 }
  828.                                                 else {
  829.                                                         curtextbegin = backward_delimiter(text, textbegin, D_pattern, D_length, OUTTAIL);
  830.                                                         curtextend = forward_delimiter(text+1, textend, D_pattern, D_length, OUTTAIL);
  831.                                                 }
  832.                         if (!OUTTAIL || INVERSE) textbegin = curtextend;
  833.                         else if (DELIMITER) textbegin = curtextend - D_length;
  834.                         else textbegin = curtextend - 1;
  835.                     }
  836.  
  837.                     DOWITHMASK = 1;
  838.                     amatched_terminals[pat_index - 1] = 1;
  839.                     if (AComplexBoolean) {
  840.                         /* Can output only after all the matches in the current record have been identified: just like filter_output */
  841.                         oldtext = text;
  842.                         CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);
  843.                         text = oldtext + pat_len[pat_index] - 1;
  844.                         MATCHED = 0;
  845.                         goto skip_output;
  846.                     }
  847.                     else if ((long)AParse & AND_EXP) {
  848.                         for (j=0; j<anum_terminals; j++) if (!amatched_terminals[j]) break;
  849.                         if (j<anum_terminals) goto skip_output;
  850.                     }
  851.                     MATCHED=1;
  852.                                         oldtext = text; /* only for MULTI_OUTPUT */
  853.  
  854. #undef    DO_OUTPUT
  855. #define DO_OUTPUT(change_text)\
  856.                     num_of_matched++;\
  857.                     if(FILENAMEONLY || SILENT)  return 0;\
  858.                     if (!COUNT) {\
  859.                         PRINTED = print_options(pat_index, text, curtextbegin, curtextend);\
  860.                         if(!INVERSE) {\
  861.                             if (PRINTRECORD) {\
  862.                             if (agrep_finalfp != NULL) {\
  863.                                 fwrite(curtextbegin, 1, curtextend - curtextbegin, agrep_finalfp);\
  864.                             }\
  865.                             else {\
  866.                                 if (agrep_outpointer + curtextend - curtextbegin>= agrep_outlen) {\
  867.                                     OUTPUT_OVERFLOW;\
  868.                                     return -1;\
  869.                                 }\
  870.                                 else {\
  871.                                     memcpy(agrep_outbuffer + agrep_outpointer, curtextbegin, curtextend-curtextbegin);\
  872.                                     agrep_outpointer += curtextend - curtextbegin;\
  873.                                 }\
  874.                             }\
  875.                             }\
  876.                             else if (PRINTED) {\
  877.                                 if (agrep_finalfp != NULL) fputc('\n', agrep_finalfp);\
  878.                                 else agrep_outbuffer[agrep_outpointer ++] = '\n';\
  879.                                 PRINTED = 0;\
  880.                             }\
  881.                                                         if ((change_text) && MULTI_OUTPUT) {     /* next match starting from end of current */\
  882.                                 CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);\
  883.                                                                 text = oldtext + pat_len[pat_index] - 1;\
  884.                                                                 MATCHED = 0;\
  885.                                                         }\
  886.                             else if (change_text) {\
  887.                                 CurrentByteOffset += textbegin - text;\
  888.                                 text = textbegin;\
  889.                             }\
  890.                         }\
  891.                         else {    /* INVERSE */\
  892.                             /* if(lastout < curtextbegin) OUT=1; */\
  893.                             if (agrep_finalfp != NULL)\
  894.                                 fwrite(lastout, 1, curtextbegin-lastout, agrep_finalfp);\
  895.                             else {\
  896.                                 if (curtextbegin - lastout + agrep_outpointer >= agrep_outlen) {\
  897.                                     OUTPUT_OVERFLOW;\
  898.                                     return -1;\
  899.                                 }\
  900.                                 memcpy(agrep_outbuffer+agrep_outpointer, lastout, curtextbegin-lastout);\
  901.                                 agrep_outpointer += (curtextbegin-lastout);\
  902.                             }\
  903.                             lastout=textbegin;\
  904.                             if (change_text) {\
  905.                                 CurrentByteOffset += textbegin - text;\
  906.                                 text = textbegin;\
  907.                             }\
  908.                         }\
  909.                     }\
  910.                     else if (change_text) {    /* COUNT */\
  911.                         CurrentByteOffset += textbegin - text;\
  912.                         text = textbegin;\
  913.                     }\
  914.                     if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||\
  915.                         ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) return 0;    /* done */\
  916.  
  917.                     DO_OUTPUT(1)
  918.                 }
  919.  
  920.             skip_output:
  921.                                 if (MATCHED && !MULTI_OUTPUT && !AComplexBoolean) break;    /* else look for more possible matches since we never know how many will match */
  922.                 if (DOWITHMASK && (text >= curtextend - 1)) {
  923.                     DOWITHMASK = 0;
  924.                     if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  925.                         DO_OUTPUT(0)
  926.                     }
  927.                     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  928.                 }
  929.             }
  930.             /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  931.             if (DOWITHMASK && (text >= curtextend - 1)) {
  932.                 DOWITHMASK = 0;
  933.                 if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  934.                     DO_OUTPUT(0)
  935.                 }
  936.                 if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  937.             }
  938.             if(!MATCHED) shift = 1;    /* || MULTI_OUTPUT is implicit */
  939.             else {
  940.                 MATCHED = 0;
  941.                 shift = m1 - 1 > 0 ? m1 - 1 : 1;
  942.             }
  943.         }
  944.  
  945.         /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  946.         if (DOWITHMASK && (text >= curtextend - 1)) {
  947.             DOWITHMASK = 0;
  948.             if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  949.                 DO_OUTPUT(0)
  950.             }
  951.             if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  952.         }
  953.  
  954.         text += shift;
  955.         CurrentByteOffset += shift;
  956.     }
  957.  
  958.     /* Do residual stuff: check if there was a match at the end of the line | check if rest of the buffer needs to be output due to inverse */
  959.  
  960.     if (DOWITHMASK && (text >= curtextend - 1)) {
  961.         DOWITHMASK = 0;
  962.         if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  963.             DO_OUTPUT(0)
  964.         }
  965.         if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  966.     }
  967.  
  968.     if(INVERSE && !COUNT && (lastout <= textend)) {
  969.                 if (agrep_finalfp != NULL) {
  970.                         while(lastout <= textend) fputc(*lastout++, agrep_finalfp);
  971.                 }
  972.                 else {
  973.                         if (textend - lastout + 1 + agrep_outpointer >= agrep_outlen) {
  974.                                 OUTPUT_OVERFLOW;
  975.                                 return -1;
  976.                         }
  977.                         memcpy(agrep_outbuffer+agrep_outpointer, lastout, textend-lastout+1);
  978.                         agrep_outpointer += (textend-lastout+1);
  979.                         lastout = textend;
  980.                 }
  981.     }
  982.  
  983.     return 0;
  984. }
  985.  
  986. #if    DOTCOMPRESSED
  987. int
  988. tc_monkey1( text, start, end  ) 
  989. int start, end;
  990. register unsigned char *text;
  991. {
  992.     int PRINTED = 0;
  993.         unsigned char *oldtext;
  994.     int pat_index;
  995.     register uchar *textend;
  996.     unsigned char *textbegin;
  997.     unsigned char *curtextend;
  998.         unsigned char *curtextbegin;
  999.     register unsigned hash;
  1000.     register uchar shift;
  1001.     register int  m1, Long=LONG;
  1002.     int MATCHED=0;
  1003.     register uchar *qx;
  1004.     register uchar *px;
  1005.     register int p, p_end;
  1006.     uchar *lastout;
  1007.     /* int OUT=0; */
  1008.     int hash2;
  1009.     int j;
  1010.     int DOWITHMASK;
  1011.     struct timeval initt, finalt;
  1012.     int newlen;
  1013.  
  1014.     DOWITHMASK = 0;
  1015.     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1016.     textbegin = text + start;
  1017.     textend = text + end;
  1018.     m1 = tc_p_size-1;
  1019.     lastout = text+start;
  1020.     text = text + start + m1 -1;
  1021.     /* -1 to allow match to the first \n in case the pattern has ^ in front of it */
  1022.     /* WORDBOUND adjustment not required */
  1023.     while (text <= textend) {
  1024.         hash=tc_tr1[*text];
  1025.         hash=(hash<<Hbits)+(tc_tr1[*(text-1)]);
  1026.         if(Long) hash=(hash<<Hbits)+(tc_tr1[*(text-2)]);
  1027.         shift = tc_SHIFT1[hash];
  1028. #ifdef perf_check
  1029.         cshift++;
  1030. #endif
  1031.         if(shift == 0) {
  1032.             hash=hash&mask5;
  1033.             hash2 = (tc_tr[*(text-m1)]<<8) + tc_tr[*(text-m1+1)];
  1034.             p = tc_HASH[hash];
  1035. #ifdef perf_check
  1036.             cshift0++;
  1037. #endif
  1038.             p_end = tc_HASH[hash+1];
  1039. #ifdef debug
  1040.             printf("hash=%d, p=%d, p_end=%d\n", hash, p, p_end);
  1041. #endif
  1042.             while(p++ < p_end) {
  1043.                 if(hash2 != tc_Hash2[p]) continue;
  1044. #ifdef perf_check
  1045.                 chash++;
  1046. #endif
  1047.                 if (((pat_index = tc_pat_indices[p]) <= 0) || (tc_pat_len[pat_index] <= 0)) continue;
  1048.                 px = tc_PatPtr[p];
  1049.                 qx = text-m1;
  1050.  
  1051.                  while((*px!=0)&&(tc_tr[*px] == tc_tr[*qx])) {
  1052.                      px++;
  1053.                      qx++;
  1054.                  }
  1055.                  if (*px == 0) {
  1056.                     if(text > textend) return 0;
  1057.                     if (!DOWITHMASK) {
  1058.                         /* Don't update CurrentByteOffset here: only before outputting properly */
  1059.                         if (!DELIMITER) {
  1060.                             curtextbegin = text; while((curtextbegin > textbegin) && (*(--curtextbegin) != '\n'));
  1061.                             if (*curtextbegin == '\n') curtextbegin ++;
  1062.                             curtextend = text+1; while((curtextend < textend) && (*curtextend != '\n')) curtextend ++;
  1063.                             if (*curtextend == '\n') curtextend ++;
  1064.                         }
  1065.                         else {
  1066.                             curtextbegin = backward_delimiter(text, textbegin, tc_D_pattern, tc_D_length, OUTTAIL);
  1067.                             curtextend = forward_delimiter(text+1, textend, tc_D_pattern, tc_D_length, OUTTAIL);
  1068.                         }
  1069.                     }
  1070.                     /* else prev curtextbegin is OK: if full AND isn't found, DOWITHMASK is 0-ed so that we search at most 1 line below */
  1071. #if    MEASURE_TIMES
  1072.                     gettimeofday(&initt, NULL);
  1073. #endif    /*MEASURE_TIMES*/
  1074.                     /* Was it really a match in the compressed line from prev line in text to text + strlen(tc_pat_len[pat_index]? */
  1075.                     if (-1==exists_tcompressed_word(tc_PatPtr[p], tc_pat_len[pat_index], curtextbegin, text - curtextbegin + tc_pat_len[pat_index], EASYSEARCH))
  1076.                         goto skip_output;
  1077. #if     MEASURE_TIMES
  1078.                     gettimeofday(&finalt, NULL);
  1079.                     FILTERALGO_ms +=  (finalt.tv_sec *1000 + finalt.tv_usec/1000) - (initt.tv_sec*1000 + initt.tv_usec/1000);
  1080. #endif  /*MEASURE_TIMES*/
  1081.                     if (!DOWITHMASK) {
  1082.                         if (!OUTTAIL || INVERSE) textbegin = curtextend;
  1083.                         else if (DELIMITER) textbegin = curtextend - D_length;
  1084.                         else textbegin = curtextend - 1;
  1085.                     }
  1086.                     DOWITHMASK = 1;
  1087.                     amatched_terminals[pat_index-1] = 1;
  1088.                     if (AComplexBoolean) {
  1089.                         /* Can output only after all the matches in the current record have been identified: just like filter_output */
  1090.                         oldtext = text;
  1091.                         CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);
  1092.                         text = oldtext + pat_len[pat_index] - 1;
  1093.                         MATCHED = 0;
  1094.                         goto skip_output;
  1095.                     }
  1096.                     else if ((long)AParse & AND_EXP) {
  1097.                         for (j=0; j<anum_terminals; j++) if (!amatched_terminals[j]) break;
  1098.                         if (j<anum_terminals) goto skip_output;
  1099.                     }
  1100.  
  1101.                     MATCHED=1;
  1102.                                         oldtext = text; /* only for MULTI_OUTPUT */
  1103.  
  1104. #undef    DO_OUTPUT
  1105. #define DO_OUTPUT(change_text)\
  1106.                     num_of_matched++;\
  1107.                     if(FILENAMEONLY || SILENT)  return 0;\
  1108.                     if (!COUNT) {\
  1109.                         PRINTED = print_options(pat_index, text, curtextbegin, curtextend);\
  1110.                         if(!INVERSE) {\
  1111.                             if (PRINTRECORD) {\
  1112. /* #if     MEASURE_TIMES\
  1113.                             gettimeofday(&initt, NULL);\
  1114. #endif  MEASURE_TIMES */\
  1115.                             if (agrep_finalfp != NULL)\
  1116.                                 newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, curtextbegin, curtextend-curtextbegin, agrep_finalfp, -1, EASYSEARCH);\
  1117.                             else {\
  1118.                                 if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, curtextbegin, curtextend-curtextbegin, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {\
  1119.                                     if (newlen + agrep_outpointer >= agrep_outlen) {\
  1120.                                         OUTPUT_OVERFLOW;\
  1121.                                         return -1;\
  1122.                                     }\
  1123.                                     agrep_outpointer += newlen;\
  1124.                                 }\
  1125.                             }\
  1126. /* #if     MEASURE_TIMES\
  1127.                             gettimeofday(&finalt, NULL);\
  1128.                             OUTFILTER_ms += (finalt.tv_sec* 1000 + finalt.tv_usec/1000) - (initt.tv_sec*1000 + initt.tv_usec/1000);\
  1129. #endif  MEASURE_TIMES */\
  1130.                             }\
  1131.                             else if (PRINTED) {\
  1132.                                 if (agrep_finalfp != NULL) fputc('\n', agrep_finalfp);\
  1133.                                 else agrep_outbuffer[agrep_outpointer ++] = '\n';\
  1134.                                 PRINTED = 0;\
  1135.                             }\
  1136.                                                         if ((change_text) && MULTI_OUTPUT) {     /* next match starting from end of current */\
  1137.                                 CurrentByteOffset += (oldtext + tc_pat_len[pat_index] - 1 - text);\
  1138.                                                                 text = oldtext + tc_pat_len[pat_index] - 1;\
  1139.                                                                 MATCHED = 0;\
  1140.                                                         }\
  1141.                             else if (change_text) {\
  1142.                                 CurrentByteOffset += textbegin - text;\
  1143.                                 text = textbegin;\
  1144.                             }\
  1145.                         }\
  1146.                         else {    /* INVERSE: Don't care about filtering time */\
  1147.                             /* if(lastout < curtextbegin) OUT=1; */\
  1148.                             if (agrep_finalfp != NULL)\
  1149.                                 newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, curtextbegin - lastout, agrep_finalfp, -1, EASYSEARCH);\
  1150.                             else {\
  1151.                                 if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, curtextbegin - lastout, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {\
  1152.                                     if (newlen + agrep_outpointer >= agrep_outlen) {\
  1153.                                         OUTPUT_OVERFLOW;\
  1154.                                         return -1;\
  1155.                                     }\
  1156.                                     agrep_outpointer += newlen;\
  1157.                                 }\
  1158.                             }\
  1159.                             lastout=textbegin;\
  1160.                             if (change_text) {\
  1161.                                 CurrentByteOffset += textbegin - text;\
  1162.                                 text = textbegin;\
  1163.                             }\
  1164.                         }\
  1165.                     }\
  1166.                     else if (change_text) {\
  1167.                         CurrentByteOffset += textbegin - text;\
  1168.                         text = textbegin;\
  1169.                     }\
  1170.                     if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||\
  1171.                         ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) return 0;    /* done */\
  1172.  
  1173.                     DO_OUTPUT(1)
  1174.                 }
  1175.  
  1176.             skip_output:
  1177.                                 if (MATCHED && !MULTI_OUTPUT && !AComplexBoolean) break;    /* else look for more possible matches since we never know how many will match */
  1178.                 if (DOWITHMASK && (text >= curtextend - 1)) {
  1179.                     DOWITHMASK = 0;
  1180.                     if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1181.                         DO_OUTPUT(0)
  1182.                     }
  1183.                     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1184.                 }
  1185.             }
  1186.             /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  1187.             if (DOWITHMASK && (text >= curtextend - 1)) {
  1188.                 DOWITHMASK = 0;
  1189.                 if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1190.                     DO_OUTPUT(0)
  1191.                 }
  1192.                 if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1193.             }
  1194.             if(!MATCHED) shift = 1;    /* || MULTI_OUTPUT is implicit */
  1195.             else {
  1196.                 MATCHED = 0;
  1197.                 shift = m1 - 1 > 0 ? m1 - 1 : 1;
  1198.             }
  1199.         }
  1200.  
  1201.         /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  1202.         if (DOWITHMASK && (text >= curtextend - 1)) {
  1203.             DOWITHMASK = 0;
  1204.             if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1205.                 DO_OUTPUT(0)
  1206.             }
  1207.             if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1208.         }
  1209.  
  1210.         text += shift;
  1211.         CurrentByteOffset += shift;
  1212.     }
  1213.  
  1214.     /* Do residual stuff: check if there was a match at the end of the line | check if rest of the buffer needs to be output due to inverse */
  1215.  
  1216.     if (DOWITHMASK && (text >= curtextend - 1)) {
  1217.         DOWITHMASK = 0;
  1218.         if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1219.             DO_OUTPUT(0)
  1220.         }
  1221.         if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1222.     }
  1223.  
  1224.     if (INVERSE && !COUNT && (lastout <= textend)) {
  1225.         if (agrep_finalfp != NULL)
  1226.             newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, textend - lastout + 1, agrep_finalfp, -1, EASYSEARCH);
  1227.         else {
  1228.             if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, textend - lastout + 1, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {
  1229.                 if (newlen + agrep_outpointer >= agrep_outlen) {
  1230.                     OUTPUT_OVERFLOW;
  1231.                     return -1;
  1232.                 }
  1233.                 agrep_outpointer += newlen;
  1234.             }
  1235.         }
  1236.     }
  1237.  
  1238.     return 0;
  1239. }
  1240. #endif    /*DOTCOMPRESSED*/
  1241.  
  1242. /* shift is always 1: slight change in MATCHED semantics: it is set to 1 even if COUNT is set: previously, it wasn't set. Will it effect m_short? */
  1243. int
  1244. m_short(text, start, end)
  1245. int start, end; register uchar *text;
  1246. {
  1247.     int PRINTED = 0;
  1248.     int pat_index;
  1249.         unsigned char *oldtext;
  1250.     register uchar *textend;
  1251.     unsigned char *textbegin;
  1252.     unsigned char *curtextend;
  1253.     unsigned char *curtextbegin;
  1254.     register int p, p_end;
  1255.     int MATCHED=0;
  1256.     /* int OUT=0; */
  1257.     uchar *lastout;
  1258.     uchar *qx;
  1259.     uchar *px;
  1260.     int j;
  1261.     int DOWITHMASK;
  1262.  
  1263.     DOWITHMASK = 0;
  1264.     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1265.     textend = text + end;
  1266.     lastout = text + start;
  1267.     textbegin = text + start;
  1268.     text = text + start - 1 ;
  1269. /*
  1270.     if (WORDBOUND || WHOLELINE) text = text-1;
  1271. */
  1272.     if (WHOLELINE) text = text-1;
  1273.         /* to accomodate the extra 2 W_delim */
  1274.     while (++text <= textend) {
  1275.         CurrentByteOffset ++;
  1276.         p = HASH[tr[*text]];
  1277.         p_end = HASH[tr[*text]+1];
  1278.         while(p++ < p_end) {
  1279.             if (((pat_index = pat_indices[p]) <= 0) || (pat_len[pat_index] <= 0)) continue;
  1280. #ifdef    debug
  1281.             printf("m_short(): p=%d pat_index=%d off=%d\n", p, pat_index, textend - text);
  1282. #endif
  1283.             px = PatPtr[p];
  1284.             qx = text;
  1285.             while((*px!=0)&&(tr[*px] == tr[*qx])) {
  1286.                 px++;
  1287.                 qx++;
  1288.             }
  1289.             if (*px == 0) {
  1290.                 if(text >= textend) return 0;
  1291.                 if (WORDBOUND) {
  1292.                     if (isalnum(*qx)) goto skip_output;
  1293.                     if (isalnum(*(text-1))) goto skip_output;
  1294.                 }
  1295.                                 if (!DOWITHMASK) {
  1296.                                         /* Don't update CurrentByteOffset here: only before outputting properly */
  1297.                                         if (!DELIMITER) {
  1298.                         curtextbegin = text; while((curtextbegin > textbegin) && (*(--curtextbegin) != '\n'));
  1299.                         if (*curtextbegin == '\n') curtextbegin ++;
  1300.                         curtextend = text+1; while((curtextend < textend) && (*curtextend != '\n')) curtextend ++;
  1301.                         if (*curtextend == '\n') curtextend ++;
  1302.                                         }
  1303.                                         else {
  1304.                                                 curtextbegin = backward_delimiter(text, textbegin, D_pattern, D_length, OUTTAIL);
  1305.                                                 curtextend = forward_delimiter(text+1, textend, D_pattern, D_length, OUTTAIL);
  1306.                                         }
  1307.                     if (!OUTTAIL || INVERSE) textbegin = curtextend;
  1308.                     else if (DELIMITER) textbegin = curtextend - D_length;
  1309.                     else textbegin = curtextend - 1;
  1310.                                 }
  1311.                                 /* else prev curtextbegin is OK: if full AND isn't found, DOWITHMASK is 0-ed so that we search at most 1 line below */
  1312.                 DOWITHMASK = 1;
  1313.  
  1314.                 amatched_terminals[pat_index - 1] = 1;
  1315.                 if (AComplexBoolean) {
  1316.                     /* Can output only after all the matches in the current record have been identified: just like filter_output */
  1317.                     oldtext = text;
  1318.                     CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);
  1319.                     text = oldtext + pat_len[pat_index] - 1;
  1320.                     MATCHED = 0;
  1321.                     goto skip_output;
  1322.                 }
  1323.                 else if ((long)AParse & AND_EXP) {
  1324.                     for (j=0; j<anum_terminals; j++) if (!amatched_terminals[j]) break;
  1325.                     if (j<anum_terminals) goto skip_output;
  1326.                 }
  1327.  
  1328.                 MATCHED = 1;
  1329.                 oldtext = text; /* used only if MULTI_OUTPUT */
  1330.  
  1331. #undef    DO_OUTPUT
  1332. #define DO_OUTPUT(change_text)\
  1333.                 num_of_matched++;\
  1334.                 if(FILENAMEONLY || SILENT)  return 0;\
  1335.                 if (!COUNT) {\
  1336.                     PRINTED = print_options(pat_index, text, curtextbegin, curtextend);\
  1337.                     if(!INVERSE) {\
  1338.                         if (PRINTRECORD) {\
  1339.                         if (agrep_finalfp != NULL) {\
  1340.                             fwrite(curtextbegin, 1, curtextend - curtextbegin, agrep_finalfp);\
  1341.                         }\
  1342.                         else {\
  1343.                             if (agrep_outpointer + curtextend - curtextbegin >= agrep_outlen) {\
  1344.                                 OUTPUT_OVERFLOW;\
  1345.                                 return -1;\
  1346.                             }\
  1347.                             else {\
  1348.                                 memcpy(agrep_outbuffer + agrep_outpointer, curtextbegin, curtextend-curtextbegin);\
  1349.                                 agrep_outpointer += curtextend - curtextbegin;\
  1350.                             }\
  1351.                         }\
  1352.                         }\
  1353.                         else if (PRINTED) {\
  1354.                             if (agrep_finalfp != NULL) fputc('\n', agrep_finalfp);\
  1355.                             else agrep_outbuffer[agrep_outpointer ++] = '\n';\
  1356.                             PRINTED = 0;\
  1357.                         }\
  1358.                                                 if ((change_text) && MULTI_OUTPUT) {     /* next match starting from end of current */\
  1359.                             CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);\
  1360.                                                         text = oldtext + pat_len[pat_index] - 1;\
  1361.                                                         MATCHED = 0;\
  1362.                                                 }\
  1363.                         else if (change_text) {\
  1364.                             CurrentByteOffset += textbegin - text;\
  1365.                             text = textbegin;\
  1366.                         }\
  1367.                     }\
  1368.                     else {\
  1369.                                                 /* if(lastout < curtextbegin) OUT=1; */\
  1370.                         if (agrep_finalfp != NULL)\
  1371.                             fwrite(lastout, 1, curtextbegin-lastout, agrep_finalfp);\
  1372.                         else {\
  1373.                             if (curtextbegin - lastout + agrep_outpointer >= agrep_outlen) {\
  1374.                                 OUTPUT_OVERFLOW;\
  1375.                                 return -1;\
  1376.                             }\
  1377.                             memcpy(agrep_outbuffer+agrep_outpointer, lastout, curtextbegin-lastout);\
  1378.                             agrep_outpointer += (curtextbegin-lastout);\
  1379.                         }\
  1380.                                                 lastout=textbegin;\
  1381.                         if (change_text) {\
  1382.                             CurrentByteOffset += textbegin - text;\
  1383.                             text = textbegin;\
  1384.                         }\
  1385.                     }\
  1386.                 }\
  1387.                 else if (change_text) {\
  1388.                     CurrentByteOffset += textbegin - text;\
  1389.                     text = textbegin;\
  1390.                 }\
  1391.                 if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||\
  1392.                     ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) return 0;    /* done */\
  1393.  
  1394.                 DO_OUTPUT(1)
  1395.             }
  1396.  
  1397.         skip_output:
  1398.                         if(MATCHED && !MULTI_OUTPUT && !AComplexBoolean) break;     /* else look for more possible matches */
  1399.             if (DOWITHMASK && (text >= curtextend - 1)) {
  1400.                 DOWITHMASK = 0;
  1401.                 if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1402.                     DO_OUTPUT(0)
  1403.                 }
  1404.                 if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1405.             }
  1406.         }
  1407.         /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  1408.         if (DOWITHMASK && (text >= curtextend - 1)) {
  1409.             DOWITHMASK = 0;
  1410.             if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1411.                 DO_OUTPUT(0)
  1412.             }
  1413.             if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1414.         }
  1415.         if (MATCHED) text --;
  1416.         MATCHED = 0;
  1417.     } /* while */
  1418.     CurrentByteOffset ++;
  1419.  
  1420.     /* Do residual stuff: check if there was a match at the end of the line | check if rest of the buffer needs to be output due to inverse */
  1421.  
  1422.     if (DOWITHMASK && (text >= curtextend - 1)) {
  1423.         DOWITHMASK = 0;
  1424.         if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1425.             DO_OUTPUT(0)
  1426.         }
  1427.         if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1428.     }
  1429.  
  1430.         if(INVERSE && !COUNT && (lastout <= textend)) {
  1431.                 if (agrep_finalfp != NULL) {
  1432.                         while(lastout <= textend) fputc(*lastout++, agrep_finalfp);
  1433.                 }
  1434.                 else {
  1435.                         if (textend - lastout + 1 + agrep_outpointer >= agrep_outlen) {
  1436.                                 OUTPUT_OVERFLOW;
  1437.                                 return -1;
  1438.                         }
  1439.                         memcpy(agrep_outbuffer+agrep_outpointer, lastout, text-lastout+1);
  1440.                         agrep_outpointer += (text-lastout+1);
  1441.                         lastout = textend;
  1442.                 }
  1443.         }
  1444.  
  1445.         return 0;
  1446. }
  1447.  
  1448. #if    DOTCOMPRESSED
  1449. /* shift is always 1: slight change in MATCHED semantics: it is set to 1 even if COUNT is set: previously, it wasn't set. Will it effect m_short? */
  1450. int
  1451. tc_m_short(text, start, end)
  1452. int start, end; register uchar *text;
  1453. {
  1454.     int PRINTED = 0;
  1455.     int pat_index;
  1456.         unsigned char *oldtext;
  1457.     register uchar *textend;
  1458.     unsigned char *textbegin;
  1459.     unsigned char *curtextend;
  1460.     unsigned char *curtextbegin;
  1461.     register int p, p_end;
  1462.     int MATCHED=0;
  1463.     /* int OUT=0; */
  1464.     uchar *lastout;
  1465.     uchar *qx;
  1466.     uchar *px;
  1467.     int j;
  1468.     int DOWITHMASK;
  1469.     struct timeval initt, finalt;
  1470.     int newlen;
  1471.  
  1472.     DOWITHMASK = 0;
  1473.     if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1474.     textend = text + end;
  1475.     lastout = text + start;
  1476.     text = text + start - 1 ;
  1477.     textbegin = text + start;
  1478.     /* WORDBOUND adjustment not required */
  1479.     while (++text <= textend) {
  1480.         CurrentByteOffset ++;
  1481.         p = tc_HASH[tc_tr[*text]];
  1482.         p_end = tc_HASH[tc_tr[*text]+1];
  1483.         while(p++ < p_end) {
  1484.             if (((pat_index = tc_pat_indices[p]) <= 0) || (tc_pat_len[pat_index] <= 0)) continue;
  1485. #ifdef    debug
  1486.             printf("m_short(): p=%d pat_index=%d off=%d\n", p, pat_index, textend - text);
  1487. #endif
  1488.             px = tc_PatPtr[p];
  1489.             qx = text;
  1490.             while((*px!=0)&&(tc_tr[*px] == tc_tr[*qx])) {
  1491.                 px++;
  1492.                 qx++;
  1493.             }
  1494.             if (*px == 0) {
  1495.                 if(text >= textend) return 0;
  1496.  
  1497.                 if (!DOWITHMASK) {
  1498.                     /* Don't update CurrentByteOffset here: only before outputting properly */
  1499.                     if (!DELIMITER) {
  1500.                         curtextbegin = text; while((curtextbegin > textbegin) && (*(--curtextbegin) != '\n'));
  1501.                         if (*curtextbegin == '\n') curtextbegin ++;
  1502.                         curtextend = text+1; while((curtextend < textend) && (*curtextend != '\n')) curtextend ++;
  1503.                         if (*curtextend == '\n') curtextend ++;
  1504.                     }
  1505.                     else {
  1506.                         curtextbegin = backward_delimiter(text, textbegin, tc_D_pattern, tc_D_length, OUTTAIL);
  1507.                         curtextend = forward_delimiter(text+1, textend, tc_D_pattern, tc_D_length, OUTTAIL);
  1508.                     }
  1509.                 }
  1510.                 /* else prev curtextbegin is OK: if full AND isn't found, DOWITHMASK is 0-ed so that we search at most 1 line below */
  1511. #if    MEASURE_TIMES
  1512.                 gettimeofday(&initt, NULL);
  1513. #endif    /*MEASURE_TIMES*/
  1514.                 /* Was it really a match in the compressed line from prev line in text to text + strlen(tc_pat_len[pat_index]? */
  1515.                 if (-1 == exists_tcompressed_word(tc_PatPtr[p], tc_pat_len[pat_index], curtextbegin, text - curtextbegin + tc_pat_len[pat_index], EASYSEARCH))
  1516.                     goto skip_output;
  1517. #if     MEASURE_TIMES
  1518.                 gettimeofday(&finalt, NULL);
  1519.                 FILTERALGO_ms +=  (finalt.tv_sec *1000 + finalt.tv_usec/1000) - (initt.tv_sec*1000 + initt.tv_usec/1000);
  1520. #endif  /*MEASURE_TIMES*/
  1521.  
  1522.                 if (!DOWITHMASK) {
  1523.                     if (!OUTTAIL || INVERSE) textbegin = curtextend;
  1524.                     else if (DELIMITER) textbegin = curtextend - D_length;
  1525.                     else textbegin = curtextend - 1;
  1526.                 }
  1527.                 DOWITHMASK = 1;
  1528.                 amatched_terminals[pat_index-1] = 1;
  1529.                 if (AComplexBoolean) {
  1530.                     /* Can output only after all the matches in the current record have been identified: just like filter_output */
  1531.                     oldtext = text;
  1532.                     CurrentByteOffset += (oldtext + pat_len[pat_index] - 1 - text);
  1533.                     text = oldtext + pat_len[pat_index] - 1;
  1534.                     MATCHED = 0;
  1535.                     goto skip_output;
  1536.                 }
  1537.                 else if ((long)AParse & AND_EXP) {
  1538.                     for (j=0; j<anum_terminals; j++) if (!amatched_terminals[j]) break;
  1539.                     if (j<anum_terminals) goto skip_output;
  1540.                 }
  1541.  
  1542.                 MATCHED = 1;
  1543.                 oldtext = text; /* used only if MULTI_OUTPUT */
  1544.  
  1545. #undef    DO_OUTPUT
  1546. #define DO_OUTPUT(change_text)\
  1547.                 num_of_matched++;\
  1548.                 if(FILENAMEONLY || SILENT)  return 0;\
  1549.                 if (!COUNT) {\
  1550.                     PRINTED = print_options(pat_index, text, curtextbegin, curtextend);\
  1551.                     if(!INVERSE) {\
  1552.                         if (PRINTRECORD) {\
  1553. /* #if     MEASURE_TIMES\
  1554.                         gettimeofday(&initt, NULL);\
  1555. #endif  MEASURE_TIMES*/\
  1556.                         if (agrep_finalfp != NULL)\
  1557.                             newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, curtextbegin, curtextend-curtextbegin, agrep_finalfp, -1, EASYSEARCH);\
  1558.                         else {\
  1559.                             if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, curtextbegin, curtextend-curtextbegin, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {\
  1560.                                 if (newlen + agrep_outpointer >= agrep_outlen) {\
  1561.                                     OUTPUT_OVERFLOW;\
  1562.                                     return -1;\
  1563.                                 }\
  1564.                                 agrep_outpointer += newlen;\
  1565.                             }\
  1566.                         }\
  1567. /*#if     MEASURE_TIMES\
  1568.                         gettimeofday(&finalt, NULL);\
  1569.                         OUTFILTER_ms +=  (finalt.tv_sec* 1000 + finalt.tv_usec/1000) - (initt.tv_sec*1000 + initt.tv_usec/1000);\
  1570. #endif  MEASURE_TIMES*/\
  1571.                         }\
  1572.                         else if (PRINTED) {\
  1573.                             if (agrep_finalfp != NULL) fputc('\n', agrep_finalfp);\
  1574.                             else agrep_outbuffer[agrep_outpointer ++] = '\n';\
  1575.                             PRINTED = 0;\
  1576.                         }\
  1577.                         if ((change_text) && MULTI_OUTPUT) {     /* next match starting from end of current */\
  1578.                             CurrentByteOffset += (oldtext + tc_pat_len[pat_index] - 1 - text);\
  1579.                             text = oldtext + tc_pat_len[pat_index] - 1;\
  1580.                             MATCHED = 0;\
  1581.                         }\
  1582.                         else if (change_text) {\
  1583.                             CurrentByteOffset += textbegin - text;\
  1584.                             text = textbegin;\
  1585.                         }\
  1586.                     }\
  1587.                     else {    /* INVERSE: Don't care about filtering time */\
  1588.                         /* if(lastout < curtextbegin) OUT=1; */\
  1589.                         if (agrep_finalfp != NULL)\
  1590.                             newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, curtextbegin - lastout, agrep_finalfp, -1, EASYSEARCH);\
  1591.                         else {\
  1592.                             if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, curtextbegin - lastout, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {\
  1593.                                 if (newlen + agrep_outpointer >= agrep_outlen) {\
  1594.                                     OUTPUT_OVERFLOW;\
  1595.                                     return -1;\
  1596.                                 }\
  1597.                                 agrep_outpointer += newlen;\
  1598.                             }\
  1599.                         }\
  1600.                         lastout=textbegin;\
  1601.                         if (change_text) {\
  1602.                             CurrentByteOffset += textbegin - text;\
  1603.                             text = textbegin;\
  1604.                         }\
  1605.                     }\
  1606.                 }\
  1607.                 else if (change_text) {\
  1608.                     CurrentByteOffset += textbegin - text;\
  1609.                     text = textbegin;\
  1610.                 }\
  1611.                 if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||\
  1612.                     ((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) return 0;    /* done */\
  1613.  
  1614.                 DO_OUTPUT(1)
  1615.             }
  1616.  
  1617.         skip_output:
  1618.                         if(MATCHED && !MULTI_OUTPUT && !AComplexBoolean) break;     /* else look for more possible matches */
  1619.             if (DOWITHMASK && (text >= curtextend - 1)) {
  1620.                 DOWITHMASK = 0;
  1621.                 if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1622.                     DO_OUTPUT(0)
  1623.                 }
  1624.                 if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1625.             }
  1626.         }
  1627.         /* If I found some match and I am about to cross over a delimiter, then set DOWITHMASK to 0 and zero out the amatched_terminals */
  1628.         if (DOWITHMASK && (text >= curtextend - 1)) {
  1629.             DOWITHMASK = 0;
  1630.             if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1631.                 DO_OUTPUT(0)
  1632.             }
  1633.             if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1634.         }
  1635.         if (MATCHED) text--;
  1636.         MATCHED = 0;
  1637.     } /* while */
  1638.     CurrentByteOffset ++;
  1639.  
  1640.     /* Do residual stuff: check if there was a match at the end of the line | check if rest of the buffer needs to be output due to inverse */
  1641.  
  1642.     if (DOWITHMASK && (text >= curtextend - 1)) {
  1643.         DOWITHMASK = 0;
  1644.         if (AComplexBoolean && dd(curtextbegin, curtextend) && eval_tree(AParse, amatched_terminals)) {
  1645.             DO_OUTPUT(0)
  1646.         }
  1647.         if (AParse != 0) memset(amatched_terminals, '\0', anum_terminals);
  1648.     }
  1649.  
  1650.     if (INVERSE && !COUNT && (lastout <= textend)) {
  1651.         if (agrep_finalfp != NULL)
  1652.             newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, textend - lastout + 1, agrep_finalfp, -1, EASYSEARCH);
  1653.         else {
  1654.             if ((newlen = quick_tuncompress(FREQ_FILE, STRING_FILE, lastout, textend - lastout + 1, agrep_outbuffer, agrep_outlen - agrep_outpointer, EASYSEARCH)) > 0) {
  1655.                 if (newlen + agrep_outpointer >= agrep_outlen) {
  1656.                     OUTPUT_OVERFLOW;
  1657.                     return -1;
  1658.                 }
  1659.                 agrep_outpointer += newlen;
  1660.             }
  1661.         }
  1662.     }
  1663.  
  1664.         return 0;
  1665. }
  1666. #endif    /*DOTCOMPRESSED*/
  1667.  
  1668. static void
  1669. f_prep(pat_index, Pattern)
  1670. uchar *Pattern;   int pat_index;
  1671. {
  1672. int i, m;
  1673. register unsigned hash=0;
  1674. #ifdef debug
  1675.     puts(Pattern);
  1676. #endif
  1677.     m = p_size;
  1678.         for (i=m-1; i>=(1+LONG); i--) {
  1679.                 hash = (tr1[Pattern[i]]);
  1680.                 hash = (hash << Hbits) + (tr1[Pattern[i-1]]);
  1681.         if(LONG) hash = (hash << Hbits) + (tr1[Pattern[i-2]] );
  1682.         if(SHIFT1[hash] >= m-1-i) SHIFT1[hash] = m-1-i;
  1683.     }
  1684.     i=m-1;
  1685.         hash = (tr1[Pattern[i]]);
  1686.         hash = (hash << Hbits) + (tr1[Pattern[i-1]]);
  1687.     if(LONG) hash = (hash << Hbits) + (tr1[Pattern[i-2]] );
  1688.         if(SHORT) hash=tr[Pattern[0]];
  1689. #ifdef debug
  1690.     printf("hash = %d\n", hash);
  1691. #endif
  1692.         HASH[hash]++;
  1693.         return;
  1694. }
  1695.  
  1696. #if    DOTCOMPRESSED
  1697. static void
  1698. tc_f_prep(pat_index, Pattern)
  1699. uchar *Pattern;   int pat_index;
  1700. {
  1701. int i, m;
  1702. register unsigned hash=0;
  1703. #ifdef debug
  1704.     puts(Pattern);
  1705. #endif
  1706.     m = tc_p_size;
  1707.         for (i=m-1; i>=(1+tc_LONG); i--) {
  1708.                 hash = (tc_tr1[Pattern[i]]);
  1709.                 hash = (hash << Hbits) + (tc_tr1[Pattern[i-1]]);
  1710.         if(tc_LONG) hash = (hash << Hbits) + (tc_tr1[Pattern[i-2]] );
  1711.         if(tc_SHIFT1[hash] >= m-1-i) tc_SHIFT1[hash] = m-1-i;
  1712.     }
  1713.     i=m-1;
  1714.         hash = (tc_tr1[Pattern[i]]);
  1715.         hash = (hash << Hbits) + (tc_tr1[Pattern[i-1]]);
  1716.     if(tc_LONG) hash = (hash << Hbits) + (tc_tr1[Pattern[i-2]] );
  1717.         if(tc_SHORT) hash=tc_tr[Pattern[0]];
  1718. #ifdef debug
  1719.     printf("hash = %d\n", hash);
  1720. #endif
  1721.         tc_HASH[hash]++;
  1722.         return;
  1723. }
  1724. #endif    /*DOTCOMPRESSED*/
  1725.  
  1726. static void
  1727. f_prep1(pat_index, Pattern)
  1728. uchar *Pattern;   int pat_index;
  1729. {
  1730. int i, m;
  1731. int hash2;
  1732. register unsigned hash;
  1733.     m = p_size;
  1734. #ifdef debug
  1735.     puts(Pattern);
  1736. #endif
  1737.         for (i=m-1; i>=(1+LONG); i--) {
  1738.                 hash = (tr1[Pattern[i]]);
  1739.                 hash = (hash << Hbits) + (tr1[Pattern[i-1]]);
  1740.         if(LONG) hash = (hash << Hbits) + (tr1[Pattern[i-2]] );
  1741.         if(SHIFT1[hash] >= m-1-i) SHIFT1[hash] = m-1-i;
  1742.     }
  1743.     i=m-1;
  1744.         hash = (tr1[Pattern[i]]);
  1745.         hash = (hash << Hbits) + (tr1[Pattern[i-1]]);
  1746.     if(LONG) hash = (hash << Hbits) + (tr1[Pattern[i-2]] );
  1747.         if(SHORT) hash=tr[Pattern[0]];
  1748.     hash2 = (tr[Pattern[0]] << 8) + tr[Pattern[1]];
  1749. #ifdef debug
  1750.     printf("hash = %d, HASH[hash] = %d\n", hash, HASH[hash]);
  1751. #endif
  1752.         PatPtr[HASH[hash]] = Pattern;
  1753.         pat_indices[HASH[hash]] = pat_index;
  1754.     Hash2[HASH[hash]] = hash2;
  1755.         HASH[hash]--;
  1756.         return;
  1757. }
  1758.  
  1759. #if    DOTCOMPRESSED
  1760. static void
  1761. tc_f_prep1(pat_index, Pattern)
  1762. uchar *Pattern;   int pat_index;
  1763. {
  1764. int i, m;
  1765. int hash2;
  1766. register unsigned hash;
  1767.     m = tc_p_size;
  1768. #ifdef debug
  1769.     puts(Pattern);
  1770. #endif
  1771.         for (i=m-1; i>=(1+tc_LONG); i--) {
  1772.                 hash = (tc_tr1[Pattern[i]]);
  1773.                 hash = (hash << Hbits) + (tc_tr1[Pattern[i-1]]);
  1774.         if(tc_LONG) hash = (hash << Hbits) + (tc_tr1[Pattern[i-2]] );
  1775.         if(tc_SHIFT1[hash] >= m-1-i) tc_SHIFT1[hash] = m-1-i;
  1776.     }
  1777.     i=m-1;
  1778.         hash = (tc_tr1[Pattern[i]]);
  1779.         hash = (hash << Hbits) + (tc_tr1[Pattern[i-1]]);
  1780.     if(tc_LONG) hash = (hash << Hbits) + (tc_tr1[Pattern[i-2]] );
  1781.         if(tc_SHORT) hash=tc_tr[Pattern[0]];
  1782.     hash2 = (tc_tr[Pattern[0]] << 8) + tc_tr[Pattern[1]];
  1783. #ifdef debug
  1784.     printf("hash = %d, tc_HASH[hash] = %d\n", hash, tc_HASH[hash]);
  1785. #endif
  1786.         tc_PatPtr[tc_HASH[hash]] = Pattern;
  1787.         tc_pat_indices[tc_HASH[hash]] = pat_index;
  1788.     tc_Hash2[tc_HASH[hash]] = hash2;
  1789.         tc_HASH[hash]--;
  1790.         return;
  1791. }
  1792. #endif    /*DOTCOMPRESSED*/
  1793.  
  1794. static void
  1795. accumulate()
  1796. {
  1797.     int i;
  1798.  
  1799.     for(i=1; i<MAXHASH; i++)  {
  1800.     /*
  1801.     printf("%d, ", HASH[i]);
  1802.     */
  1803.     HASH[i] = HASH[i-1] + HASH[i];
  1804.     }
  1805.     HASH[0] = 0;
  1806.     return;
  1807. }
  1808.  
  1809. #if    DOTCOMPRESSED
  1810. static void
  1811. tc_accumulate()
  1812. {
  1813.     int i;
  1814.  
  1815.     for(i=1; i<MAXHASH; i++)  {
  1816.     /*
  1817.     printf("%d, ", HASH[i]);
  1818.     */
  1819.     tc_HASH[i] = tc_HASH[i-1] + tc_HASH[i];
  1820.     }
  1821.     tc_HASH[0] = 0;
  1822.     return;
  1823. }
  1824. #endif    /*DOTCOMPRESSED*/
  1825.  
  1826.  
  1827.